﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lesson_3
{
    internal class Program
    {
        static void Main(string[] args)
        {

            #region 练习

            // 使用最少两种方法 在控制台打印出下面的内容 
            // 大家好,我是张三,
            // 今天很开心见到大家,
            // 我的爱好是:好好学习,
            // 天天向上,
            // 希望和大家称为朋友

            //Console.WriteLine("大家好,我是张三,");
            //Console.WriteLine("今天很开心见到大家,");
            //Console.WriteLine("我的爱好是:好好学习,");
            //Console.WriteLine("天天向上,");
            //Console.WriteLine("希望和大家称为朋友"); 

            // Console.WriteLine("大家好,我是张三,\n今天很开心见到大家,\n我的爱好是:好好学习,\n天天向上,\n希望和大家称为朋友");

            //Console.Write("大家好,我是张三,");
            //Console.WriteLine();
            //Console.Write("今天很开心见到大家,");
            //Console.WriteLine();
            //Console.Write("我的爱好是:好好学习,");
            //Console.WriteLine();
            //Console.Write("天天向上,");
            //Console.WriteLine();
            //Console.Write("希望和大家称为朋友");
            //Console.WriteLine();

            //Console.Write("大家好,我是张三,\n");
            //Console.Write("今天很开心见到大家,\n");
            //Console.Write("我的爱好是:好好学习,\n");
            //Console.Write("天天向上,\n");
            //Console.Write("希望和大家称为朋友\n");
            #endregion

            #region 类型转换
            // 1.类型转换: 类型转换就是不同变量类型之间的相互转换,
            // 2.隐式转换的基本规则: 不同变量类型之间会自动转换
            // 2.1 隐式转换: 小范围自动转为大范围 
            // 2.2 有符号整型变量转换  
            //     a.long(-9百万兆 到 9百万兆) => int( -21亿多 到 21亿多) => short( -32768 到 32767) => sbyte( -128 到 127 );
            //     b.举例: 
            long l1 = 1;
            int i1 = 1;
            short s1 = 1;
            sbyte sb1 = 1;
            // = : 赋值符号, 把等号右边的值赋值给左边
            // l1(大范围) = i1(小范围);  隐式转换 把int隐式转换成了long
            // i1(小范围) = l1(大范围); 报错, 原因:不能用大范围去转为小范围 
            l1 = s1; 
            l1 = sb1;
            s1 = sb1;
            // 2.3 无符号整型变量转换 
            //   a.ulong( 0到18百万兆 ) => uint( 0到42亿多 ) => ushort( 0到65535 ) => byte( 0到255)
            //   b.举例: 
            ulong ul1 = 1;
            uint ui1 = 1;
            ushort us1 = 1;
            byte b1 = 1;

            ul1 = ui1;
            ul1 = us1;
            ul1 = b1;
            ui1 = us1;
            ui1 = b1;
            us1 = b1;

            // 2.4 浮点数 
            //    a. decimal( 27到28有效数字)  double(15到17位有效数字) => float(7到8位有效数字) 
            //    b. 举例: 
            decimal de1 = 1.1m;
            double d1 = 1;
            float f1 = 1.1f;
            //    c. decimal这个类型没有办法用隐式转换的形式去存储 double和 float的值 
            //de1 = d1;  报错
            //de1 = f1;  报错 
            //    d. float可以隐式转为double 
            d1 = f1;
            // 2.5 特殊类型  bool char string 
            //     特殊类型之间不存在相互转换 

            // 2.6 不同大类型之间的转换 
            //    a. 无符号(正数和0) 不能转成负数 
            //    b. 举例: 
            // 无符号
            byte b2 = 1;
            ushort us2 = 1;
            uint ui2 = 1;
            ulong ul2 = 1;
            // 有符号
            sbyte sb2 = 1;
            short s2 = 1;
            int i2 = 1;
            long l2 = 1;
            //   c. 有符号的不能隐式转为无符号的 
            //b2 = sb2;
            //us2 = sb2;
            //ul2 = sb2; 
            //   d. 上面三个转换都报错, 原因: 有符号包含的有负数
            //   e. 无符号的可以隐式转为有符号的( 注意: 范围是包含在内, 有符号的范围必须包含无符号的范围   ) 
            //i2 = b2;
            //i2 = us2;
            //i2 = ui2; // 报错, 原因: ui2范围是0到42亿多,  i2范围是-21亿多到21亿多.  ui2超过了i2最大的存储范围.

            // 2.7 浮点数和整数(有符号,无符号)之间相互转换
            //   a.举例: 
            float f2 = 1.1f;
            double d2 = 12.3;
            decimal de2 = 123.4m;
            //  b. 任何类型的整数是可以隐式转为浮点数 
            f2 = ul2;
            f2 = l2;
            f2 = ui2;
            f2 = i2;

            d2 = f2;
            d2 = ul2;

            //  c. float和double没有办法隐式转为decimal, 但是 整型变量可以隐式转为decimal 
            //de2 = f2; 报错
            //de2 = d2; 报错
            de2 = ul2;
            de2 = l2;

            //  d. 浮点数不能隐式转为任何类型的整数 原因: 整数不能存小数
            //l2 = f2;  报错
            //ul2 = f2; 报错

            // 2.7 特殊类型和其他类型之间 
            //  a. 举例:
            bool bo2 = true;
            char ch2 = 'a';
            string str2 = "123A";
            //  b. bool,char,string没有办法和其他类型之间进行隐式转换.
            //bo2 = i2;
            //ch2 = i2;
            //str2 = i2;

            // 3. 显示转换 
            // 3.1 将大范围转为小范围
            // 3.2 括号强转 ( 将大范围转为小范围 )  
            //    a. 语法: 变量类型 变量名 = (变量类型)变量名
            //             小范围  小范围  =  (小范围)大范围
            //    b.注意问题: 范围问题 
            //    c.举例: 
            sbyte sb3 = 1;
            short s3 = 1;
            int i3 = 1;
            long l3 = 1;
           // i3 = s3; 隐式转换 
            s3 = (short)i3; 

            byte b3 = 1;    //   0-255
            ushort us3 = 300; // 0-65535
            uint ui3 = 1;
            ulong ul3 = 1;
            // ul3 = ui3; 隐式转换
            ui3 = (uint)ul3;
            Console.WriteLine( ui3 ); // 1
            //   d.强转的时候可能会因为范围问题造成的异常
            b3 = (byte)us3;
            Console.WriteLine(b3);    // 44 
            //   e.无符号和有符号之间转换 
            ui2 = (uint)i2;
            Console.WriteLine(ui2);
            //  f. 整型和浮点数之间, 浮点数 强转为 整型的时候 会直接抛弃小数点 
            i3 = (int)1.7f;
            Console.WriteLine(i3);
            //  g. char和数值类型 
            i3 = 'A';
            char c = (char)i3;
            Console.WriteLine(c);
            //  h.bool和string 不能通过括号强装

            // 3.3 Parse法 
            //   a. 作用:把字符串类型转为对应的类型 
            //   b. 语法结构: 变量类型.Parse("字符串") 
            //   c. 注意问题: 字符串必须能够转为对应的类型,否则报错  
            //   d. 举例: 
            string str3 = "123";
            int i4 = int.Parse(str3);
            Console.WriteLine(i4);

            //str3 = "123A";
            //str3 = "123A";
            //i4 = int.Parse(str3);
            //Console.WriteLine(i4); // 报错, 原因:输入字符串的格式不正确。A不能转为int类型
            //   e: 注意问题: 范围问题,值得范围必能够被变量存储, 
            //sbyte sb4 = sbyte.Parse("200");
            //Console.WriteLine(sb4);  // 报错,原因:值对于带符号的字节太大或太小. sbyte范围只能存储-128到127的值.超过就报错了 

             float f3 = float.Parse("12.3");
            Console.WriteLine(f3);
            bool b4 = bool.Parse("true");
            Console.WriteLine(b4);
            char c4 = char.Parse("C");
            Console.WriteLine(c4);

            // 3.4 Convert法 ( 把字符串转为对应的类型 )
            //   a. 作用: 更准确将各个类型之间进行相互转换 
            //   b. 语法结构: Convert.To目标类型(变量) 
            //   c. 注意问题: 填写的变量必须正确,  
            //   d. 举例: 
            int i5 = Convert.ToInt32("12");
            Console.WriteLine(i5);
            //   e.通过sizeof方法得到每个变量所占的内存空间,单位:字节, 1字节 = 8位
            //     int: 4个字节, 32位.   long: 8个字节, 64位,  short: 2个字节, 16位,  sbyte: 1个字节 8位 
            long l5 = Convert.ToInt64("12");
            int i55 = Convert.ToInt32("12");
            short s5 = Convert.ToInt16("12");
            sbyte sb5 = Convert.ToSByte("12");

            ulong ul5 = Convert.ToUInt64("12");
            uint ui5 = Convert.ToUInt32("12");
            ushort us5 = Convert.ToUInt16("12");
            byte b5 = Convert.ToByte("12");

            float f5 = Convert.ToSingle("12.3");
            double d5 = Convert.ToDouble("12.3");
            decimal de5 = Convert.ToDecimal("12.3");

            bool bo5 = Convert.ToBoolean("true");
            char c5 = Convert.ToChar("C");
            string str5 = Convert.ToString("123");










            #endregion


        }
    }
}
